from flask import request, jsonify
from aps import app
from aps.models.tipoitem import *
from aps.models.tipoitematributo import *
from aps.models.fase import *
from aps.models.fasetipoitem import *

@app.route('/crear_tipoitem', methods=['GET', 'POST'])  
def crear_tipoitem():
    """
    Nos permite traer los parametros que fueron cargados por el usuario
    y guardarlos en la base de datos.
    @param request: objeto que encapsula la peticion del cliente
    @return : True si la accion se realizo correctamente
    """     
    id_fase       = request.form['id_fase']
    nombre        = request.form['nombre']
    descripcion   = request.form['descripcion']
    prefijo       = request.form['prefijo']
    
    # se agrega a la BD
    model         = Tipoitem(nombre, descripcion, prefijo)
    bdsession.add(model)
    bdsession.flush()
    id_tipoitem = model.id
    
    # se asigna el tipo de item a la fase seleccionada
    fase          = bdsession.query(Fase).filter_by(id=id_fase).first()
    fase.tipoitems.append(FaseTipoitem(id_fase,id_tipoitem))
    bdsession.merge(fase)
    
    # asignamos los atributos base
    model.atributos.append(TipoitemAtributo(id_tipoitem,1))
    model.atributos.append(TipoitemAtributo(id_tipoitem,2))
    model.atributos.append(TipoitemAtributo(id_tipoitem,3))
    model.atributos.append(TipoitemAtributo(id_tipoitem,4))
    bdsession.merge(model)
        
    return jsonify ({'success' : True})

@app.route('/modificar_tipoitem', methods=['GET', 'POST'])  
def modificar_tipoitem():
    """
    Nos permite traer los parametros que fueron modificados por el usuario
    y guardar los cambios en la base de datos.
    @param request: objeto que encapsula la peticion del cliente
    @return: True si la accion se realizo correctamente
    """ 
    id           = request.form['id']
    nombre       = request.form['nombre']
    descripcion  = request.form['descripcion']
    prefijo      = request.form['prefijo']
    # Se modifica en la BD
    model        = Tipoitem(nombre,descripcion,prefijo)
    model.id     = id
    bdsession.merge(model)
    return jsonify ({'success':True})

@app.route('/eliminar_tipoitem', methods=['GET', 'POST'])  
def eliminar_tipoitem():
    """
    Nos permite traer el id del tipoitem a eliminar, eliminar las dependendcias
    del mismo con respecto a otras tablas y eliminar el registro de la base de datos.
    @param request: objeto que encapsula la peticion del cliente
    @return: True si la accion se realizo correctamente y False en caso contrario
    """ 
    print 'hola'
    id = request.form['id']
    print id
    tipoitem = bdsession.query(Tipoitem).filter_by(id=id).first()
    if tipoitem is None:
        return jsonify ({'success':False})
    # eliminamos de la BD
    tipoitem.eliminar_dependencias()
    bdsession.refresh(tipoitem)
    bdsession.delete(tipoitem)
    
    return jsonify ({'success':True})

@app.route('/consultar_tipoitem', methods=['GET', 'POST'])  
def consultar_tipoitem():
    """
    Nos permite traer los parametros de consulta(el filtro y el valor) y mostrar
    los tipoitems que cumplen con la condicion del filtro.
    @param request: objeto que encapsula la peticion del cliente
    @return: si la accion se realizo correctamente
    """
    id_fase = request.args['idfase']
    # Obtenemos los tipoitems que pertenecen a la fase
    tipoitems = bdsession.query(Fase).filter_by(id=id_fase).first().tipoitems
    if request.args.has_key('filtro'):
        filtro    = request.args['filtro']
        valor     = request.args['valor']
        # Realizamos un filtro, si se necesita
        tipoitems  = [ ti for ti in tipoitems if str(ti.tipoitem.__dict__[filtro]) == str(valor) ]
    # Obtenemos los tipo items a procesar
    tipoitems = [ ti.tipoitem for ti in tipoitems ]
    data = []
    for tipoitem in tipoitems:
        item = {}
        item['id']          = tipoitem.id
        item['nombre']      = tipoitem.nombre
        item['descripcion'] = tipoitem.descripcion
        item['prefijo']     = tipoitem.prefijo
        data.append(item)
    return jsonify ({'success':True, 'data':data, 'total':len(data)})

@app.route('/consultar_tipoitem_importar', methods=['GET', 'POST'])  
def consultar_tipoitem_importar():
    """
    Nos permite traer todos los tipo de item de una fase
    @param request: objeto que encapsula la peticion del cliente
    @return: si la accion se realizo correctamente
    """
    if not request.args.has_key('idfase'):
        return jsonify ({'success':False, 'total':0, 'data':[]})

    id_fase = request.args['idfase']
    # Obtenemos los tipoitems que pertenecen a la fase
    tipoitems = bdsession.query(Fase).filter_by(id=id_fase).first().tipoitems
    # Obtenemos los tipo items a procesar
    tipoitems = [ ti.tipoitem for ti in tipoitems ]
    data = []
    for tipoitem in tipoitems:
        item = {}
        item['id']          = tipoitem.id
        item['nombre']      = tipoitem.nombre
        item['descripcion'] = tipoitem.descripcion
        item['prefijo']     = tipoitem.prefijo
        data.append(item)
    return jsonify ({'success':True, 'data':data, 'total':len(data)})

@app.route('/consultar_tipoitem_fase', methods=['GET', 'POST'])  
def consultar_tipoitem_fase():
    """
    Nos permite obtener una lista de tipo item por fase
    @param request: objeto que encapsula la peticion del cliente
    @return: True si la accion se realizo correctamente
    """
    if not request.args.has_key('id_fase'):
        return jsonify ({'success':False, 'total':0, 'data':[]})

    id_fase = request.args['id_fase']    
    fase = bdsession.query(Fase).filter_by(id=id_fase).first()
    data = []
    for rti in fase.tipoitems:
        item = {}
        item['id']     = rti.tipoitem.id
        item['nombre'] = rti.tipoitem.nombre
        data.append(item)
    return jsonify ({'success':True, 'total':len(data), 'data':data})

@app.route('/consulta_tipoitem_x_fase', methods=['GET', 'POST'])  
def consulta_tipoitem_x_fase():
    """
    Nos permite obtener la lista detallada de tipoitem asignados a una fase
    @param request: objeto que encapsula la peticion del cliente
    @return: True si la accion se realizo correctamente
    """
    id_fase = request.args['id_fase']
    fase    = bdsession.query(Fase).filter_by(id=id_fase).first()
    data = []
    for tipoitem in fase.tipoitems:
        item = {}
        item['id'] = tipoitem.tipoitem.id
        item['nombre'] = tipoitem.tipoitem.nombre
        item['descripcion'] = tipoitem.tipoitem.descripcion
        item['prefijo'] = tipoitem.tipoitem.prefijo
        data.append(item)
    return jsonify ({'success':True, 'data':data, 'total':len(data)})
    
@app.route('/importar_tipoitem', methods=['GET', 'POST'])  
def importar_tipoitem():
    """
    Nos permite importar un tipo de item y sus atributos de otro proyecto.
    @param request: objeto que encapsula la peticion del cliente
    @return: True si la accion se realizo correctamente
    """ 
    id_tipoitem = request.form['id_tipoitem']
    id_fase = request.form['id_fase']
    fase        = bdsession.query(Fase).filter_by(id=id_fase).first() 
    tipoitem    = bdsession.query(Tipoitem).filter_by(id=id_tipoitem).first() 
    # clonamos el tipo de item
    model         = Tipoitem(tipoitem.nombre, tipoitem.descripcion, tipoitem.prefijo)
    bdsession.add(model)
    bdsession.flush()
    id_ti = model.id 
        
    # agregamos a la fase del combo el tipoitem clonado
    fase.tipoitems.append(FaseTipoitem(id_fase,id_ti))
    
    # guardamos los cambios
    bdsession.merge(fase)
    
    #obtenemos el tipo de item nuevo
    tin = bdsession.query(Tipoitem).filter_by(id=id_ti).first()
    
    # relacionamos cada atributo del tipo de item viejo con el tipo de item clonado
    for atributo in tipoitem.atributos:
        tin.atributos.append(TipoitemAtributo(id_ti, atributo.atributo.id))
    
    # guardamos los cambios
    bdsession.merge(tin)
    
    return jsonify ({'success' : True})